home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Add-Ons / MPW / MPW re2c 1.1 / examples / rexx / rexx.l < prev    next >
Encoding:
Text File  |  1995-06-01  |  5.4 KB  |  320 lines  |  [TEXT/MPS ]
  1. #include "scanio.h"
  2. #include "scanner.h"
  3.  
  4. #define    CURSOR        ch
  5. #define    LOADCURSOR    ch = *cursor;
  6. #define    ADVANCE        cursor++;
  7. #define    BACK(n)        cursor -= (n);
  8. #define    CHECK(n)    if((ScanCB.lim - cursor) < (n)){cursor = ScanFill(cursor);}
  9. #define    MARK(n)        ScanCB.ptr = cursor; sel = (n);
  10. #define    REVERT        cursor = ScanCB.ptr;
  11. #define    MARKER        sel
  12.  
  13. #define    RETURN(i)    {ScanCB.cur = cursor; return i;}
  14.  
  15. int ScanToken(){
  16.     uchar *cursor = ScanCB.cur;
  17.     unsigned sel;
  18.     uchar ch;
  19.     ScanCB.tok = cursor;
  20.     ScanCB.eot = NULL;
  21. /*!re2c
  22. all    = [\000-\377];
  23. eof    = [\000];
  24. any    = all\eof;
  25. letter    = [a-z]|[A-Z];
  26. digit    = [0-9];
  27. symchr    = letter|digit|[.!?_];
  28. const    = (digit|[.])symchr*([eE][+-]?digit+)?;
  29. simple    = (symchr\(digit|[.]))(symchr\[.])*;
  30. stem    = simple [.];
  31. symbol    = symchr*;
  32. sqstr    = ['] ((any\['\n])|(['][']))* ['];
  33. dqstr    = ["] ((any\["\n])|(["]["]))* ["];
  34. str    = sqstr|dqstr;
  35. ob    = [ \t]*;
  36. not    = [\\~];
  37. A    = [aA];
  38. B    = [bB];
  39. C    = [cC];
  40. D    = [dD];
  41. E    = [eE];
  42. F    = [fF];
  43. G    = [gG];
  44. H    = [hH];
  45. I    = [iI];
  46. J    = [jJ];
  47. K    = [kK];
  48. L    = [lL];
  49. M    = [mM];
  50. N    = [nN];
  51. O    = [oO];
  52. P    = [pP];
  53. Q    = [qQ];
  54. R    = [rR];
  55. S    = [sS];
  56. T    = [tT];
  57. U    = [uU];
  58. V    = [vV];
  59. W    = [wW];
  60. X    = [xX];
  61. Y    = [yY];
  62. Z    = [zZ];
  63. */
  64.  
  65. scan:
  66. /*!re2c
  67. "\n"
  68.         {
  69.         ++(ScanCB.lineNum);
  70.         ScanCB.linePos = ScanCB.pos + (cursor - ScanCB.mrk);
  71.         RETURN(SU_EOL);
  72.         }
  73. "|" ob "|"
  74.         { RETURN(OP_CONCAT); }
  75. "+"
  76.         { RETURN(OP_PLUS); }
  77. "-"
  78.         { RETURN(OP_MINUS); }
  79. "*"
  80.         { RETURN(OP_MULT); }
  81. "/"
  82.         { RETURN(OP_DIV); }
  83. "%"
  84.         { RETURN(OP_IDIV); }
  85. "/" ob "/"
  86.         { RETURN(OP_REMAIN); }
  87. "*" ob "*"
  88.         { RETURN(OP_POWER); }
  89. "="
  90.         { RETURN(OP_EQUAL); }
  91. not ob "=" | "<" ob ">" | ">" ob "<"
  92.         { RETURN(OP_EQUAL_N); }
  93. ">"
  94.         { RETURN(OP_GT); }
  95. "<"
  96.         { RETURN(OP_LT); }
  97. ">" ob "=" | not ob "<"
  98.         { RETURN(OP_GE); }
  99. "<" ob "=" | not ob ">"
  100.         { RETURN(OP_LE); }
  101. "=" ob "="
  102.         { RETURN(OP_EQUAL_EQ); }
  103. not ob "=" ob "="
  104.         { RETURN(OP_EQUAL_EQ_N); }
  105. ">" ob ">"
  106.         { RETURN(OP_GT_STRICT); }
  107. "<" ob "<"
  108.         { RETURN(OP_LT_STRICT); }
  109. ">" ob ">" ob "=" | not ob "<" ob "<"
  110.         { RETURN(OP_GE_STRICT); }
  111. "<" ob "<" ob "=" | not ob ">" ob ">"
  112.         { RETURN(OP_LE_STRICT); }
  113. "&"
  114.         { RETURN(OP_AND); }
  115. "|"
  116.         { RETURN(OP_OR); }
  117. "&" ob "&"
  118.         { RETURN(OP_XOR); }
  119. not
  120.         { RETURN(OP_NOT); }
  121.  
  122. ":"
  123.         { RETURN(SU_COLON); }
  124. ","
  125.         { RETURN(SU_COMMA); }
  126. "("
  127.         { RETURN(SU_POPEN); }
  128. ")"
  129.         { RETURN(SU_PCLOSE); }
  130. ";"
  131.         { RETURN(SU_EOC); }
  132.  
  133. A D D R E S S
  134.         { RETURN(RX_ADDRESS); }
  135. A R G
  136.         { RETURN(RX_ARG); }
  137. C A L L
  138.         { RETURN(RX_CALL); }
  139. D O
  140.         { RETURN(RX_DO); }
  141. D R O P
  142.         { RETURN(RX_DROP); }
  143. E L S E
  144.         { RETURN(RX_ELSE); }
  145. E N D
  146.         { RETURN(RX_END); }
  147. E X I T
  148.         { RETURN(RX_EXIT); }
  149. I F
  150.         { RETURN(RX_IF); }
  151. I N T E R P R E T
  152.         { RETURN(RX_INTERPRET); }
  153. I T E R A T E
  154.         { RETURN(RX_ITERATE); }
  155. L E A V E
  156.         { RETURN(RX_LEAVE); }
  157. N O P
  158.         { RETURN(RX_NOP); }
  159. N U M E R I C
  160.         { RETURN(RX_NUMERIC); }
  161. O P T I O N S
  162.         { RETURN(RX_OPTIONS); }
  163. O T H E R W I S E
  164.         { RETURN(RX_OTHERWISE); }
  165. P A R S E
  166.         { RETURN(RX_PARSE); }
  167. P R O C E D U R E
  168.         { RETURN(RX_PROCEDURE); }
  169. P U L L
  170.         { RETURN(RX_PULL); }
  171. P U S H
  172.         { RETURN(RX_PUSH); }
  173. Q U E U E
  174.         { RETURN(RX_QUEUE); }
  175. R E T U R N
  176.         { RETURN(RX_RETURN); }
  177. S A Y
  178.         { RETURN(RX_SAY); }
  179. S E L E C T
  180.         { RETURN(RX_SELECT); }
  181. S I G N A L
  182.         { RETURN(RX_SIGNAL); }
  183. T H E N
  184.         { RETURN(RX_THEN); }
  185. T R A C E
  186.         { RETURN(RX_TRACE); }
  187. W H E N
  188.         { RETURN(RX_WHEN); }
  189. O F F
  190.         { RETURN(RXS_OFF); }
  191. O N
  192.         { RETURN(RXS_ON); }
  193. B Y
  194.         { RETURN(RXS_BY); }
  195. D I G I T S
  196.         { RETURN(RXS_DIGITS); }
  197. E N G I N E E R I N G
  198.         { RETURN(RXS_ENGINEERING); }
  199. E R R O R
  200.         { RETURN(RXS_ERROR); }
  201. E X P O S E
  202.         { RETURN(RXS_EXPOSE); }
  203. F A I L U R E
  204.         { RETURN(RXS_FAILURE); }
  205. F O R
  206.         { RETURN(RXS_FOR); }
  207. F O R E V E R
  208.         { RETURN(RXS_FOREVER); }
  209. F O R M
  210.         { RETURN(RXS_FORM); }
  211. F U Z Z
  212.         { RETURN(RXS_FUZZ); }
  213. H A L T
  214.         { RETURN(RXS_HALT); }
  215. L I N E I N
  216.         { RETURN(RXS_LINEIN); }
  217. N A M E
  218.         { RETURN(RXS_NAME); }
  219. N O T R E A D Y
  220.         { RETURN(RXS_NOTREADY); }
  221. N O V A L U E
  222.         { RETURN(RXS_NOVALUE); }
  223. S C I E N T I F I C
  224.         { RETURN(RXS_SCIENTIFIC); }
  225. S O U R C E
  226.         { RETURN(RXS_SOURCE); }
  227. S Y N T A X
  228.         { RETURN(RXS_SYNTAX); }
  229. T O
  230.         { RETURN(RXS_TO); }
  231. U N T I L
  232.         { RETURN(RXS_UNTIL); }
  233. U P P E R
  234.         { RETURN(RXS_UPPER); }
  235. V A L U E
  236.         { RETURN(RXS_VALUE); }
  237. V A R
  238.         { RETURN(RXS_VAR); }
  239. V E R S I O N
  240.         { RETURN(RXS_VERSION); }
  241. W H I L E
  242.         { RETURN(RXS_WHILE); }
  243. W I T H
  244.         { RETURN(RXS_WITH); }
  245.  
  246. const
  247.         { RETURN(SU_CONST); }
  248. simple
  249.         { RETURN(SU_SYMBOL); }
  250. stem
  251.         { RETURN(SU_SYMBOL_STEM); }
  252. symbol
  253.         { RETURN(SU_SYMBOL_COMPOUND); }
  254. str
  255.         { RETURN(SU_LITERAL); }
  256. str [bB] / (all\symchr)
  257.         { RETURN(SU_LITERAL_BIN); }
  258. str [xX] / (all\symchr)
  259.         { RETURN(SU_LITERAL_HEX); }
  260.  
  261. eof
  262.         { RETURN(SU_EOF); }
  263. any
  264.         { RETURN(SU_ERROR); }
  265. */
  266. }
  267.  
  268. bool StripToken(){
  269.     uchar *cursor = ScanCB.cur;
  270.     unsigned depth;
  271.     uchar ch;
  272.     bool blanks = FALSE;
  273.     ScanCB.eot = cursor;
  274. strip:
  275. /*!re2c
  276. "/*"
  277.         {
  278.         depth = 1;
  279.         goto comment;
  280.         }
  281. "\r"
  282.         { goto strip; }
  283. [ \t]
  284.         {
  285.         blanks = TRUE;
  286.         goto strip;
  287.         }
  288. [] / all
  289.         { RETURN(blanks); }
  290. */
  291.  
  292. comment:
  293. /*!re2c
  294. "*/"
  295.         {
  296.         if(--depth == 0)
  297.             goto strip;
  298.         else
  299.             goto comment;
  300.         }
  301. "\n"
  302.         {
  303.         ++(ScanCB.lineNum);
  304.         ScanCB.linePos = ScanCB.pos + (cursor - ScanCB.mrk);
  305.         goto comment;
  306.         }
  307. "/*"
  308.         {
  309.         ++depth;
  310.         goto comment;
  311.         }
  312. eof
  313.         { RETURN(blanks); }
  314. any
  315.         {
  316.         goto comment;
  317.         }
  318. */
  319. }
  320.